home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 10 / AACD 10.iso / AACD / Games / MAME / src / memory.h < prev    next >
C/C++ Source or Header  |  2000-05-18  |  15KB  |  384 lines
  1. #ifndef MEMORY_H
  2. #define MEMORY_H
  3.  
  4. #include "osd_cpu.h"
  5. #include <stddef.h>
  6.  
  7.  
  8. #define MAX_BANKS        16
  9.  
  10.  
  11. /***************************************************************************
  12.     Core memory read/write/opbase handler types.
  13. ***************************************************************************/
  14.  
  15. typedef UINT32 offs_t;
  16. typedef UINT32 data_t;
  17.  
  18. typedef data_t (*mem_read_handler)(offs_t offset);
  19. typedef void (*mem_write_handler)(offs_t offset,data_t data);
  20. typedef offs_t (*opbase_handler)(offs_t address);
  21.  
  22. #ifdef DJGPP
  23. #define READ_HANDLER(name)        data_t name(offs_t __attribute__ ((unused)) offset)
  24. #define WRITE_HANDLER(name)     void name(offs_t __attribute__ ((unused)) offset,data_t __attribute__ ((unused)) data)
  25. #define OPBASE_HANDLER(name)    offs_t name(offs_t __attribute__ ((unused)) address)
  26. #else
  27. #define READ_HANDLER(name)        data_t name(offs_t offset)
  28. #define WRITE_HANDLER(name)     void name(offs_t offset,data_t data)
  29. #define OPBASE_HANDLER(name)    offs_t name(offs_t address)
  30. #endif
  31.  
  32.  
  33.  
  34. /***************************************************************************
  35.  
  36. Note that the memory hooks are not passed the actual memory address where
  37. the operation takes place, but the offset from the beginning of the block
  38. they are assigned to. This makes handling of mirror addresses easier, and
  39. makes the handlers a bit more "object oriented". If you handler needs to
  40. read/write the main memory area, provide a "base" pointer: it will be
  41. initialized by the main engine to point to the beginning of the memory block
  42. assigned to the handler. You may also provided a pointer to "size": it
  43. will be set to the length of the memory area processed by the handler.
  44.  
  45. ***************************************************************************/
  46.  
  47. struct MemoryReadAddress
  48. {
  49.     offs_t start, end;
  50.     mem_read_handler handler;                /* see special values below */
  51. };
  52.  
  53. #define MRA_NOP   0                         /* don't care, return 0 */
  54. #define MRA_RAM   ((mem_read_handler)-1)    /* plain RAM location (return its contents) */
  55. #define MRA_ROM   ((mem_read_handler)-2)    /* plain ROM location (return its contents) */
  56. #define MRA_BANK1 ((mem_read_handler)-10)    /* bank memory */
  57. #define MRA_BANK2 ((mem_read_handler)-11)    /* bank memory */
  58. #define MRA_BANK3 ((mem_read_handler)-12)    /* bank memory */
  59. #define MRA_BANK4 ((mem_read_handler)-13)    /* bank memory */
  60. #define MRA_BANK5 ((mem_read_handler)-14)    /* bank memory */
  61. #define MRA_BANK6 ((mem_read_handler)-15)    /* bank memory */
  62. #define MRA_BANK7 ((mem_read_handler)-16)    /* bank memory */
  63. #define MRA_BANK8 ((mem_read_handler)-17)    /* bank memory */
  64. #define MRA_BANK9 ((mem_read_handler)-18)    /* bank memory */
  65. #define MRA_BANK10 ((mem_read_handler)-19)    /* bank memory */
  66. #define MRA_BANK11 ((mem_read_handler)-20)    /* bank memory */
  67. #define MRA_BANK12 ((mem_read_handler)-21)    /* bank memory */
  68. #define MRA_BANK13 ((mem_read_handler)-22)    /* bank memory */
  69. #define MRA_BANK14 ((mem_read_handler)-23)    /* bank memory */
  70. #define MRA_BANK15 ((mem_read_handler)-24)    /* bank memory */
  71. #define MRA_BANK16 ((mem_read_handler)-25)    /* bank memory */
  72.  
  73. struct MemoryWriteAddress
  74. {
  75.     offs_t start, end;
  76.     mem_write_handler handler;                /* see special values below */
  77.     unsigned char **base;                    /* optional (see explanation above) */
  78.     size_t *size;                            /* optional (see explanation above) */
  79. };
  80.  
  81. #define MWA_NOP 0                            /* do nothing */
  82. #define MWA_RAM ((mem_write_handler)-1)     /* plain RAM location (store the value) */
  83. #define MWA_ROM ((mem_write_handler)-2)     /* plain ROM location (do nothing) */
  84. /*
  85.    If the CPU opcodes are encrypted, they are fetched from a different memory space.
  86.    In such a case, if the program dynamically creates code in RAM and executes it,
  87.    it won't work unless you use MWA_RAMROM to affect both memory spaces.
  88.  */
  89. #define MWA_RAMROM ((mem_write_handler)-3)
  90. #define MWA_BANK1 ((mem_write_handler)-10)    /* bank memory */
  91. #define MWA_BANK2 ((mem_write_handler)-11)    /* bank memory */
  92. #define MWA_BANK3 ((mem_write_handler)-12)    /* bank memory */
  93. #define MWA_BANK4 ((mem_write_handler)-13)    /* bank memory */
  94. #define MWA_BANK5 ((mem_write_handler)-14)    /* bank memory */
  95. #define MWA_BANK6 ((mem_write_handler)-15)    /* bank memory */
  96. #define MWA_BANK7 ((mem_write_handler)-16)    /* bank memory */
  97. #define MWA_BANK8 ((mem_write_handler)-17)    /* bank memory */
  98. #define MWA_BANK9 ((mem_write_handler)-18)    /* bank memory */
  99. #define MWA_BANK10 ((mem_write_handler)-19) /* bank memory */
  100. #define MWA_BANK11 ((mem_write_handler)-20) /* bank memory */
  101. #define MWA_BANK12 ((mem_write_handler)-21) /* bank memory */
  102. #define MWA_BANK13 ((mem_write_handler)-22) /* bank memory */
  103. #define MWA_BANK14 ((mem_write_handler)-23) /* bank memory */
  104. #define MWA_BANK15 ((mem_write_handler)-24) /* bank memory */
  105. #define MWA_BANK16 ((mem_write_handler)-25) /* bank memory */
  106.  
  107.  
  108.  
  109. /***************************************************************************
  110.  
  111. IN and OUT ports are handled like memory accesses, the hook template is the
  112. same so you can interchange them. Of course there is no 'base' pointer for
  113. IO ports.
  114.  
  115. ***************************************************************************/
  116.  
  117. struct IOReadPort
  118. {
  119.     int start,end;
  120.     mem_read_handler handler;                /* see special values below */
  121. };
  122.  
  123. #define IORP_NOP 0    /* don't care, return 0 */
  124.  
  125.  
  126. struct IOWritePort
  127. {
  128.     int start,end;
  129.     mem_write_handler handler;                /* see special values below */
  130. };
  131.  
  132. #define IOWP_NOP 0    /* do nothing */
  133.  
  134.  
  135. /***************************************************************************
  136.  
  137. If a memory region contains areas that are outside of the ROM region for
  138. an address space, the memory system will allocate an array of structures
  139. to track the external areas.
  140.  
  141. ***************************************************************************/
  142.  
  143. #define MAX_EXT_MEMORY 64
  144.  
  145. struct ExtMemory
  146. {
  147.     int start,end,region;
  148.     unsigned char *data;
  149. };
  150.  
  151. extern struct ExtMemory ext_memory[MAX_EXT_MEMORY];
  152.  
  153.  
  154.  
  155. /***************************************************************************
  156.  
  157. For a given number of address bits, we need to determine how many elements
  158. there are in the first and second-order lookup tables. We also need to know
  159. how many low-order bits to ignore. The ABITS* values represent these
  160. constants for each address space type we support.
  161.  
  162. ***************************************************************************/
  163.  
  164. /* memory element block size */
  165. #define MH_SBITS        8            /* sub element bank size */
  166. #define MH_PBITS        8            /* port current element size */
  167. #define MH_ELEMAX        64            /* sub elements limit */
  168. #define MH_HARDMAX        64            /* hardware functions limit */
  169.  
  170. /* 16 bits address */
  171. #define ABITS1_16        12
  172. #define ABITS2_16        4
  173. #define ABITS_MIN_16    0            /* minimum memory block is 1 byte */
  174. /* 16 bits address (little endian word access) */
  175. #define ABITS1_16LEW    12
  176. #define ABITS2_16LEW    3
  177. #define ABITS_MIN_16LEW 1            /* minimum memory block is 2 bytes */
  178. /* 16 bits address (big endian word access) */
  179. #define ABITS1_16BEW    12
  180. #define ABITS2_16BEW    3
  181. #define ABITS_MIN_16BEW 1            /* minimum memory block is 2 bytes */
  182. /* 20 bits address */
  183. #define ABITS1_20        12
  184. #define ABITS2_20        8
  185. #define ABITS_MIN_20    0            /* minimum memory block is 1 byte */
  186. /* 21 bits address */
  187. #define ABITS1_21        13
  188. #define ABITS2_21        8
  189. #define ABITS_MIN_21    0            /* minimum memory block is 1 byte */
  190. /* 24 bits address (word access - byte granularity) */
  191. #define ABITS1_24        16
  192. #define ABITS2_24        8
  193. #define ABITS_MIN_24    0            /* minimum memory block is 1 byte */
  194. /* 24 bits address (big endian - word access) */
  195. #define ABITS1_24BEW    15
  196. #define ABITS2_24BEW    8
  197. #define ABITS_MIN_24BEW 1            /* minimum memory block is 2 bytes */
  198. /* 29 bits address (dword access) */
  199. #define ABITS1_29        19
  200. #define ABITS2_29        8
  201. #define ABITS_MIN_29    2            /* minimum memory block is 4 bytes */
  202. /* 32 bits address (dword access) */
  203. #define ABITS1_32        23
  204. #define ABITS2_32        8
  205. #define ABITS_MIN_32    1            /* minimum memory block is 2 bytes */
  206. /* 32 bits address (little endian dword access) */
  207. #define ABITS1_32LEW    23
  208. #define ABITS2_32LEW    8
  209. #define ABITS_MIN_32LEW 1            /* minimum memory block is 2 bytes */
  210. /* mask bits */
  211. #define MHMASK(abits)     (0xffffffff >> (32 - abits))
  212.  
  213.  
  214. /***************************************************************************
  215.  
  216.     Global variables
  217.  
  218. ***************************************************************************/
  219.  
  220. typedef unsigned char MHELE;
  221.  
  222. extern MHELE ophw;                        /* opcode handler */
  223. extern MHELE *cur_mrhard;                /* current set of read handlers */
  224. extern MHELE *cur_mwhard;                /* current set of write handlers */
  225.  
  226. extern unsigned char *OP_RAM;            /* opcode RAM base */
  227. extern unsigned char *OP_ROM;            /* opcode ROM base */
  228. extern unsigned char *cpu_bankbase[];    /* array of bank bases */
  229.  
  230.  
  231.  
  232. /***************************************************************************
  233.  
  234.     Macros
  235.  
  236. ***************************************************************************/
  237.  
  238. /* ----- 16-bit memory accessing ----- */
  239. #define READ_WORD(a)          (*(UINT16 *)(a))
  240. #define WRITE_WORD(a,d)       (*(UINT16 *)(a) = (d))
  241. #define COMBINE_WORD(w,d)      (((w) & ((d) >> 16)) | ((d) & 0xffff))
  242. #define COMBINE_WORD_MEM(a,d) (WRITE_WORD((a), (READ_WORD(a) & ((d) >> 16)) | (d)))
  243.  
  244. /* ----- opcode reading ----- */
  245. #define cpu_readop(A)        (OP_ROM[A])
  246. #define cpu_readop16(A)     READ_WORD(&OP_ROM[A])
  247. #define cpu_readop_arg(A)   (OP_RAM[A])
  248. #define cpu_readop_arg16(A) READ_WORD(&OP_RAM[A])
  249.  
  250. /* ----- bank switching for CPU cores ----- */
  251. #define change_pc_generic(pc,abits2,abitsmin,shift,setop)    \
  252. {                                                            \
  253.     if (cur_mrhard[(pc)>>(abits2+abitsmin+shift)] != ophw)    \
  254.         setop(pc);                                            \
  255. }
  256. #define change_pc(pc)        change_pc_generic(pc, ABITS2_16, ABITS_MIN_16, 0, cpu_setOPbase16)
  257. #define change_pc16(pc)     change_pc_generic(pc, ABITS2_16, ABITS_MIN_16, 0, cpu_setOPbase16)
  258. #define change_pc16bew(pc)    change_pc_generic(pc, ABITS2_16BEW, ABITS_MIN_16BEW, 0, cpu_setOPbase16bew)
  259. #define change_pc16lew(pc)    change_pc_generic(pc, ABITS2_16LEW, ABITS_MIN_16LEW, 0, cpu_setOPbase16lew)
  260. #define change_pc20(pc)     change_pc_generic(pc, ABITS2_20, ABITS_MIN_20, 0, cpu_setOPbase20)
  261. #define change_pc21(pc)     change_pc_generic(pc, ABITS2_21, ABITS_MIN_21, 0, cpu_setOPbase21)
  262. #define change_pc24(pc)     change_pc_generic(pc, ABITS2_24, ABITS_MIN_24, 0, cpu_setOPbase24)
  263. #define change_pc24bew(pc)    change_pc_generic(pc, ABITS2_24BEW, ABITS_MIN_24BEW, 0, cpu_setOPbase24bew)
  264. #define change_pc29(pc)     change_pc_generic(pc, ABITS2_29, ABITS_MIN_29, 3, cpu_setOPbase29)
  265. #define change_pc32(pc)     change_pc_generic(pc, ABITS2_32, ABITS_MIN_32, 0, cpu_setOPbase32)
  266. #define change_pc32lew(pc)    change_pc_generic(pc, ABITS2_32LEW, ABITS_MIN_32LEW, 0, cpu_setOPbase32lew)
  267.  
  268. /* ----- for use OPbaseOverride driver, request override callback to next cpu_setOPbase ----- */
  269. #define catch_nextBranch()    (ophw = 0xff)
  270.  
  271. /* -----  bank switching macro ----- */
  272. #define cpu_setbank(bank, base)                         \
  273. {                                                        \
  274.     if (bank >= 1 && bank <= MAX_BANKS)                 \
  275.     {                                                    \
  276.         cpu_bankbase[bank] = (UINT8 *)(base);            \
  277.         if (ophw == bank)                                \
  278.         {                                                \
  279.             ophw = 0xff;                                \
  280.             cpu_setOPbase16(cpu_get_pc());                \
  281.         }                                                \
  282.     }                                                    \
  283. }
  284.  
  285.  
  286. /***************************************************************************
  287.  
  288.     Function prototypes
  289.  
  290. ***************************************************************************/
  291.  
  292. /* ----- memory setup function ----- */
  293. int memory_init(void);
  294. void memory_shutdown(void);
  295. void memorycontextswap(int activecpu);
  296.  
  297. /* ----- memory read functions ----- */
  298. READ_HANDLER(cpu_readmem16);
  299. READ_HANDLER(cpu_readmem16bew);
  300. READ_HANDLER(cpu_readmem16bew_word);
  301. READ_HANDLER(cpu_readmem16lew);
  302. READ_HANDLER(cpu_readmem16lew_word);
  303. READ_HANDLER(cpu_readmem20);
  304. READ_HANDLER(cpu_readmem21);
  305. READ_HANDLER(cpu_readmem24);
  306. READ_HANDLER(cpu_readmem24bew);
  307. READ_HANDLER(cpu_readmem24bew_word);
  308. READ_HANDLER(cpu_readmem24bew_dword);
  309. READ_HANDLER(cpu_readmem29);
  310. READ_HANDLER(cpu_readmem29_word);
  311. READ_HANDLER(cpu_readmem29_dword);
  312. READ_HANDLER(cpu_readmem32);
  313. READ_HANDLER(cpu_readmem32_word);
  314. READ_HANDLER(cpu_readmem32_dword);
  315. READ_HANDLER(cpu_readmem32lew);
  316. READ_HANDLER(cpu_readmem32lew_word);
  317. READ_HANDLER(cpu_readmem32lew_dword);
  318.  
  319. /* ----- memory write functions ----- */
  320. WRITE_HANDLER(cpu_writemem16);
  321. WRITE_HANDLER(cpu_writemem16bew);
  322. WRITE_HANDLER(cpu_writemem16bew_word);
  323. WRITE_HANDLER(cpu_writemem16lew);
  324. WRITE_HANDLER(cpu_writemem16lew_word);
  325. WRITE_HANDLER(cpu_writemem20);
  326. WRITE_HANDLER(cpu_writemem21);
  327. WRITE_HANDLER(cpu_writemem24);
  328. WRITE_HANDLER(cpu_writemem24bew);
  329. WRITE_HANDLER(cpu_writemem24bew_word);
  330. WRITE_HANDLER(cpu_writemem24bew_dword);
  331. WRITE_HANDLER(cpu_writemem29);
  332. WRITE_HANDLER(cpu_writemem29_word);
  333. WRITE_HANDLER(cpu_writemem29_dword);
  334. WRITE_HANDLER(cpu_writemem32);
  335. WRITE_HANDLER(cpu_writemem32_word);
  336. WRITE_HANDLER(cpu_writemem32_dword);
  337. WRITE_HANDLER(cpu_writemem32lew);
  338. WRITE_HANDLER(cpu_writemem32lew_word);
  339. WRITE_HANDLER(cpu_writemem32lew_dword);
  340.  
  341. /* ----- port I/O functions ----- */
  342. int cpu_readport(int port);
  343. void cpu_writeport(int port, int value);
  344.  
  345. /* ----- dynamic memory/port mapping ----- */
  346. void *install_mem_read_handler(int cpu, int start, int end, mem_read_handler handler);
  347. void *install_mem_write_handler(int cpu, int start, int end, mem_write_handler handler);
  348. void *install_port_read_handler(int cpu, int start, int end, mem_read_handler handler);
  349. void *install_port_write_handler(int cpu, int start, int end, mem_write_handler handler);
  350.  
  351. /* ----- dynamic bank handlers ----- */
  352. void cpu_setbankhandler_r(int bank, mem_read_handler handler);
  353. void cpu_setbankhandler_w(int bank, mem_write_handler handler);
  354.  
  355. /* ----- opcode base control ---- */
  356. void cpu_setOPbase16(int pc);
  357. void cpu_setOPbase16bew(int pc);
  358. void cpu_setOPbase16lew(int pc);
  359. void cpu_setOPbase20(int pc);
  360. void cpu_setOPbase21(int pc);
  361. void cpu_setOPbase24(int pc);
  362. void cpu_setOPbase24bew(int pc);
  363. void cpu_setOPbase29(int pc);
  364. void cpu_setOPbase32(int pc);
  365. void cpu_setOPbase32lew(int pc);
  366. void cpu_setOPbaseoverride(int cpu, opbase_handler function);
  367.  
  368. /* ----- harder-to-explain functions ---- */
  369.  
  370. /* use this to set the a different opcode base address when using a CPU with
  371.    opcodes and data encrypted separately */
  372. void memory_set_opcode_base(int cpu, unsigned char *base);
  373.  
  374. /* look up a chunk of memory and get its start/end addresses, and its base.
  375. Pass in the cpu number and the offset. It will find the chunk containing
  376. that offset and return the start and end addresses, along with a pointer to
  377. the base of the memory.
  378. This can be used (carefully!) by drivers that wish to access memory directly
  379. without going through the readmem/writemem accessors (e.g., blitters). */
  380. unsigned char *findmemorychunk(int cpu, int offset, int *chunkstart, int *chunkend);
  381.  
  382. #endif
  383.  
  384.